home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / ddj0897.zip / DYN401.ZIP / class / string.c < prev    next >
C/C++ Source or Header  |  1997-04-16  |  24KB  |  1,081 lines
  1.  
  2.  
  3. /*  Copyright (c) 1993-1996 Algorithms Corporation  */
  4. /*  All rights reserved.  */
  5.  
  6.  
  7.  
  8.  
  9. /*  This file automatically generated by dpp - do not edit  */
  10.  
  11. #define    DPP_STRATEGY    2
  12. #define    DPP_FASTWIDE    0
  13.  
  14.  
  15.  
  16. #line 16 "string.d"
  17. #include "memalloc.h" 
  18. #include <ctype.h> 
  19. #include <string.h> 
  20. #include <math.h> 
  21.  
  22. #if 0 
  23. #define ADJUST 
  24. #endif 
  25.  
  26. #define    CLASS    String_c
  27. #define    ivType    String_iv_t
  28.  
  29. #include "generics.h"
  30.  
  31. object    String_c;
  32.  
  33.  
  34. #line 35 "string.c"
  35. typedef struct  _String_iv_t  {
  36.     char * iStr;
  37.     int iSize;
  38.     int iLen;
  39.     int iBlksz;
  40.     int iCalcLen;
  41.     int iFum;
  42. }    String_iv_t;
  43.  
  44.  
  45. #line 41 "string.d"
  46. #define SETSIZE(x) iv->iSize = ((x) ? (((x)-1)/iv->iBlksz + 1) * iv->iBlksz : 0) 
  47.  
  48. #define ABS 40 
  49.  
  50. #define UPDATE_LEN if (iv->iCalcLen) iv->iLen = strlen(iv->iStr) 
  51.  
  52.  
  53. #ifndef max 
  54. #define max(a,b) ((a) > (b) ? (a) : (b)) 
  55. #endif 
  56.  
  57.  
  58. #ifdef ADJUST 
  59.  
  60.  
  61.  
  62.  
  63. #define FREE_UNUSED if (iv->iFum && iv->iLen+1 <= iv->iSize-iv->iBlksz) { SETSIZE(iv->iLen+1); iv->iStr = (char *) MA_realloc(iv->iStr, iv->iSize); } 
  64. #else 
  65. #define FREE_UNUSED 
  66. #endif 
  67.  
  68.  
  69. static int get_string(object, char **, char *, int); 
  70.  
  71.  
  72.  
  73. cmeth objrtn New(object self, char *so)
  74. { 
  75.     object obj = oSuper(String_c, gNew, self)(self); 
  76.     ivType *iv = ivPtr(obj); 
  77.     char *str; 
  78.     int len; 
  79.  
  80.     len = get_string((object) so, &str, "New", 2); 
  81.     iv->iBlksz = 1; 
  82.     SETSIZE(len + 1); 
  83.     iv->iStr = (char *) MA_malloc(iv->iSize, &iv->iStr); 
  84.     if (len) 
  85.         memcpy(iv->iStr, str, len); 
  86.     iv->iStr[len] = '\0'; 
  87.     iv->iLen = len; 
  88.     return(obj); 
  89. } 
  90.  
  91. cmeth objrtn String_cm_gNewWithInt(object self, int len)
  92. { 
  93.     object obj = oSuper(String_c, gNew, self)(self); 
  94.     ivType *iv = ivPtr(obj); 
  95.  
  96.     iv->iBlksz = 1; 
  97.     SETSIZE(len + 1); 
  98.     iv->iStr = (char *) MA_malloc(iv->iSize, &iv->iStr); 
  99.     *iv->iStr = '\0'; 
  100.     iv->iCalcLen = 1; 
  101.     iv->iLen = 0; 
  102.     return(obj); 
  103. } 
  104.  
  105. cmeth objrtn String_cm_gNewWithObj(object self, object so)
  106. { 
  107.     return New(self, (char *) so); 
  108. } 
  109.  
  110. cmeth objrtn String_cm_gNew(object self)
  111. { 
  112.     return New(self, ""); 
  113. } 
  114.  
  115. imeth char * String_im_gStringValue(object self)
  116. { String_iv_t *iv = GetIVs(String, self);
  117.     return iv->iStr; 
  118. } 
  119.  
  120. imeth int String_im_gSize(object self)
  121. { String_iv_t *iv = GetIVs(String, self);
  122.     UPDATE_LEN; 
  123.     return iv->iLen; 
  124. } 
  125.  
  126. imeth objrtn ChangeValue(object self, object obj)
  127. { String_iv_t *iv = GetIVs(String, self);
  128.     char *str; 
  129.     int len; 
  130.  
  131.     len = get_string(obj, &str, "ChangeValue", 2); 
  132.     iv->iLen = len; 
  133.     if (len >= iv->iSize) { 
  134.         SETSIZE(iv->iLen + 1); 
  135.         iv->iStr = (char *) MA_realloc(iv->iStr, iv->iSize); 
  136.     } 
  137.     if (len) 
  138.         memcpy(iv->iStr, str, len); 
  139.     iv->iStr[len] = '\0'; 
  140.     FREE_UNUSED; 
  141.     return self; 
  142. } 
  143.  
  144. imeth objrtn String_im_gChangeStrValue(object self, char *str)
  145. { 
  146.     return ChangeValue(self, (object) str); 
  147. } 
  148.  
  149. imeth objrtn String_im_gDispose(object self)
  150. { String_iv_t *iv = GetIVs(String, self);
  151.     if (iv->iStr) 
  152.         MA_free(iv->iStr); 
  153.     return oSuper(String_c, gDispose, self)(self); 
  154. } 
  155.  
  156. imeth int String_im_gHash(object self)
  157. { String_iv_t *iv = GetIVs(String, self);
  158.     register char c = 'a'; 
  159.     char *s = iv->iStr; 
  160.     double t; 
  161.     register unsigned short k=0; 
  162.  
  163.     while (*s) 
  164.         k += *s++ ^ c++; 
  165.     t = .6125423371 * k; 
  166.     return (int) (BIG_INT * (t - floor(t))); 
  167. } 
  168.  
  169. imeth int String_im_gCompare(object self, object obj)
  170. { String_iv_t *iv = GetIVs(String, self);
  171.     char *s, *t; 
  172.     int tlen, slen; 
  173.  
  174.     if (IsObj(obj)) { 
  175.         ivType *iv2; 
  176.  
  177.         if (!gIsKindOf(obj, CLASS)) 
  178.             return oSuper(String_c, gCompare, self)(self, obj); 
  179.         iv2 = ivPtr(obj); 
  180.         t = iv2->iStr; 
  181.         if (iv2->iCalcLen) 
  182.             iv2->iLen = strlen(t); 
  183.         tlen = iv2->iLen; 
  184.     } else { 
  185.         t = (char *) obj; 
  186.         tlen = t ? strlen(t) : 0; 
  187.     } 
  188.     UPDATE_LEN; 
  189.     slen = iv->iLen; 
  190.     s = iv->iStr; 
  191.     while (slen && tlen && *s == *t) { 
  192.         s++; 
  193.         t++; 
  194.         slen--; 
  195.         tlen--; 
  196.     } 
  197.     if (!slen && !tlen) 
  198.         return 0; 
  199.     if (!slen) 
  200.         return -1; 
  201.     if (!tlen) 
  202.         return 1; 
  203.     return *(unsigned char *)s - *(unsigned char *)t; 
  204. } 
  205.  
  206. imeth int String_im_gCompareI(object self, object obj)
  207. { String_iv_t *iv = GetIVs(String, self);
  208.     char *s, *t; 
  209.     int tlen, slen; 
  210.  
  211.     if (IsObj(obj)) { 
  212.         ivType *iv2; 
  213.  
  214.         if (!gIsKindOf(obj, CLASS)) 
  215.             gError(self, "CompareI::String:  Arg 2 incorrect type.\n"); 
  216.         iv2 = ivPtr(obj); 
  217.         t = iv2->iStr; 
  218.         if (iv2->iCalcLen) 
  219.             iv2->iLen = strlen(t); 
  220.         tlen = iv2->iLen; 
  221.     } else { 
  222.         t = (char *) obj; 
  223.         tlen = t ? strlen(t) : 0; 
  224.     } 
  225.     UPDATE_LEN; 
  226.     slen = iv->iLen; 
  227.     s = iv->iStr; 
  228.     while (slen && tlen && tolower(*s) == tolower(*t)) { 
  229.         s++; 
  230.         t++; 
  231.         slen--; 
  232.         tlen--; 
  233.     } 
  234.     if (!slen && !tlen) 
  235.         return 0; 
  236.     if (!slen) 
  237.         return -1; 
  238.     if (!tlen) 
  239.         return 1; 
  240.     return tolower(*(unsigned char *)s) - tolower(*(unsigned char *)t); 
  241. } 
  242.  
  243. imeth int String_im_gCompareN(object self, object obj, int n)
  244. { String_iv_t *iv = GetIVs(String, self);
  245.     char *s, *t; 
  246.     int tlen, slen; 
  247.  
  248.     if (IsObj(obj)) { 
  249.         ivType *iv2; 
  250.  
  251.         if (!gIsKindOf(obj, CLASS)) 
  252.             gError(self, "CompareN::String:  Arg 2 incorrect type.\n"); 
  253.         iv2 = ivPtr(obj); 
  254.         t = iv2->iStr; 
  255.         if (iv2->iCalcLen) 
  256.             iv2->iLen = strlen(t); 
  257.         tlen = iv2->iLen; 
  258.     } else { 
  259.         t = (char *) obj; 
  260.         tlen = t ? strlen(t) : 0; 
  261.     } 
  262.     UPDATE_LEN; 
  263.     slen = iv->iLen; 
  264.     s = iv->iStr; 
  265.     while (n && slen && tlen && *s == *t) { 
  266.         s++; 
  267.         t++; 
  268.         n--; 
  269.         slen--; 
  270.         tlen--; 
  271.     } 
  272.     if (!n || !slen && !tlen) 
  273.         return 0; 
  274.     if (!slen) 
  275.         return -1; 
  276.     if (!tlen) 
  277.         return 1; 
  278.     return *(unsigned char *)s - *(unsigned char *)t; 
  279. } 
  280.  
  281. imeth int String_im_gCompareNI(object self, object obj, int n)
  282. { String_iv_t *iv = GetIVs(String, self);
  283.     char *s, *t; 
  284.     int tlen, slen; 
  285.  
  286.     if (IsObj(obj)) { 
  287.         ivType *iv2; 
  288.  
  289.         if (!gIsKindOf(obj, CLASS)) 
  290.             gError(self, "CompareNI::String:  Arg 2 incorrect type.\n"); 
  291.         iv2 = ivPtr(obj); 
  292.         t = iv2->iStr; 
  293.         if (iv2->iCalcLen) 
  294.             iv2->iLen = strlen(t); 
  295.         tlen = iv2->iLen; 
  296.     } else { 
  297.         t = (char *) obj; 
  298.         tlen = t ? strlen(t) : 0; 
  299.     } 
  300.     UPDATE_LEN; 
  301.     slen = iv->iLen; 
  302.     s = iv->iStr; 
  303.     while (n && slen && tlen && tolower(*s) == tolower(*t)) { 
  304.         s++; 
  305.         t++; 
  306.         n--; 
  307.         slen--; 
  308.         tlen--; 
  309.     } 
  310.     if (!n || !slen && !tlen) 
  311.         return 0; 
  312.     if (!slen) 
  313.         return -1; 
  314.     if (!tlen) 
  315.         return 1; 
  316.     return tolower(*(unsigned char *)s) - tolower(*(unsigned char *)t); 
  317. } 
  318.  
  319. imeth objrtn String_im_gStringRepValue(object self)
  320. { String_iv_t *iv = GetIVs(String, self);
  321.     return vSprintf(String, "\"%s\"", iv->iStr ? iv->iStr : "(null)"); 
  322. } 
  323.  
  324. imeth int String_im_gPrintLength(object self, int t)
  325. { String_iv_t *iv = GetIVs(String, self);
  326.     register int n=0; 
  327.     int l=0; 
  328.     char *s; 
  329.  
  330.     UPDATE_LEN; 
  331.     if (!iv->iLen) 
  332.         return(0); 
  333.     for (s=iv->iStr ; *s && *s != '\n' ; ++s) 
  334.         switch (*s) { 
  335.         case '\t': 
  336.         n += t - n % t; 
  337.         break; 
  338.         case '\b': 
  339.         if (n) 
  340.             --n; 
  341.         break; 
  342.         case '\r': 
  343.         l = max(n, l); 
  344.         n = 0; 
  345.         break; 
  346.         default: 
  347.         if (isprint(*s)) 
  348.             ++n; 
  349.         break; 
  350.     } 
  351.     return max(l, n); 
  352. } 
  353.  
  354. #define more n 
  355. #define next s++, n-- 
  356.  
  357. static int Val(char c, int b) 
  358. { 
  359.     int n; 
  360.  
  361.     if (isdigit(c)) n = c - '0'; 
  362.     else if (isalpha(c)) n = toupper(c) - ('A' - 10); 
  363.     else return(-1); 
  364.     if (n >= b) return(-1); 
  365.     return(n); 
  366. } 
  367.  
  368. imeth objrtn String_im_gProcess(object self)
  369. { String_iv_t *iv = GetIVs(String, self);
  370.     char *s, *d; 
  371.     int a, i, n; 
  372.  
  373.     UPDATE_LEN; 
  374.     s = d = iv->iStr; 
  375.     for (n=iv->iLen ; more ; ) 
  376.         if (*s != '\\') { 
  377.         *d++ = *s; 
  378.         next; 
  379.     } else { 
  380.         next; 
  381.         if (!more) 
  382.             break; 
  383.         switch (*s) { 
  384.             case 'N': 
  385.             case 'n': 
  386.             *d++ = '\n'; 
  387.             next; 
  388.             break; 
  389.             case 'T': 
  390.             case 't': 
  391.             *d++ = '\t'; 
  392.             next; 
  393.             break; 
  394.             case 'B': 
  395.             case 'b': 
  396.             *d++ = '\b'; 
  397.             next; 
  398.             break; 
  399.             case 'R': 
  400.             case 'r': 
  401.             *d++ = '\r'; 
  402.             next; 
  403.             break; 
  404.             case 'F': 
  405.             case 'f': 
  406.             *d++ = '\f'; 
  407.             next; 
  408.             break; 
  409.             case 'E': 
  410.             case 'e': 
  411.             *d++ = 27; 
  412.             next; 
  413.             break; 
  414.             case 'A': 
  415.             case 'a': 
  416.             *d++ = 7; 
  417.             next; 
  418.             break; 
  419.             case 'V': 
  420.             case 'v': 
  421.             *d++ = '\v'; 
  422.             next; 
  423.             break; 
  424.             case '^': 
  425.             next; 
  426.             if (!more) 
  427.                 goto end; 
  428.             *d++ = tolower(*s) - ('a' - 1); 
  429.             next; 
  430.             break; 
  431.             case 'X': 
  432.             case 'x': 
  433.             *d = '\0'; 
  434.             for (i = 0, next ; more && (a = Val(*s, 16)) != -1 && i != 2; next, ++i) 
  435.                 *d = 16 * *d + a; 
  436.             ++d; 
  437.             break; 
  438.             case 'D': 
  439.             case 'd': 
  440.             *d = '\0'; 
  441.             for (i = 0, next ; more && (a = Val(*s, 10)) != -1 && i != 3; next, ++i) 
  442.                 *d = 10 * *d + a; 
  443.             ++d; 
  444.             break; 
  445.             case '\0': 
  446.             break; 
  447.             default: 
  448.             if (isdigit(*s)) { 
  449.                 *d = '\0'; 
  450.                 for (i = 0; more && (a = Val(*s, 8)) != -1 && i != 3; next, ++i) 
  451.                     *d = 8 * *d + a; 
  452.                 ++d; 
  453.                 break; 
  454.             } 
  455.             *d++ = *s; 
  456.             next; 
  457.             break; 
  458.         } 
  459.     } 
  460.     end: 
  461.     *d = '\0'; 
  462.     iv->iLen = d - iv->iStr; 
  463.     FREE_UNUSED; 
  464.     return self; 
  465. } 
  466.  
  467. imeth objrtn String_im_gAppend(object self, object obj)
  468. { String_iv_t *iv = GetIVs(String, self);
  469.     char *str; 
  470.     int len, need; 
  471.  
  472.     if (!obj) 
  473.         return self; 
  474.     UPDATE_LEN; 
  475.     len = get_string(obj, &str, "Append", 2); 
  476.     need = iv->iLen + 1 + len; 
  477.     if (need > iv->iSize) { 
  478.         if (iv->iBlksz == 1) 
  479.             iv->iBlksz = ABS; 
  480.         SETSIZE(need); 
  481.         iv->iStr = (char *) MA_realloc(iv->iStr, iv->iSize); 
  482.     } 
  483.     memcpy(iv->iStr + iv->iLen, str, len); 
  484.     iv->iLen += len; 
  485.     iv->iStr[iv->iLen] = '\0'; 
  486.     return self; 
  487. } 
  488.  
  489. imeth int String_im_gWrite(object self, char *buf, unsigned len)
  490. { String_iv_t *iv = GetIVs(String, self);
  491.     int need; 
  492.  
  493.     UPDATE_LEN; 
  494.     need = iv->iLen + 1 + len; 
  495.     if (need > iv->iSize) { 
  496.         if (iv->iBlksz == 1) 
  497.             iv->iBlksz = ABS; 
  498.         SETSIZE(need); 
  499.         iv->iStr = (char *) MA_realloc(iv->iStr, iv->iSize); 
  500.     } 
  501.     memcpy(iv->iStr + iv->iLen, buf, len); 
  502.     iv->iLen += len; 
  503.     iv->iStr[iv->iLen] = '\0'; 
  504.     return len; 
  505. } 
  506.  
  507. imeth int String_im_gRead(object self, char *buf, unsigned n)
  508. { String_iv_t *iv = GetIVs(String, self);
  509.     int len; 
  510.  
  511.     UPDATE_LEN; 
  512.     len = n > (unsigned) iv->iLen ? iv->iLen : (int) n; 
  513.     memcpy(buf, iv->iStr, len); 
  514.     memmove(iv->iStr, iv->iStr+len, iv->iLen-len+1); 
  515.     iv->iLen -= len; 
  516.     FREE_UNUSED; 
  517.     return len; 
  518. } 
  519.  
  520. imeth char * String_im_gGets(object self, char *buf, int n)
  521. { String_iv_t *iv = GetIVs(String, self);
  522.     int len; 
  523.  
  524.     UPDATE_LEN; 
  525.     if (!iv->iLen) 
  526.         return NULL; 
  527.     if (n <= 0) 
  528.         return NULL; 
  529.     if (n-- == 1) { 
  530.         *buf = '\0'; 
  531.         return buf; 
  532.     } 
  533.     for (len=0 ; len < iv->iLen && iv->iStr[len++] != '\n' ; ); 
  534.     memcpy(buf, iv->iStr, len); 
  535.     memmove(iv->iStr, iv->iStr+len, iv->iLen-len+1); 
  536.     iv->iLen -= len; 
  537.     FREE_UNUSED; 
  538.     buf[len] = '\0'; 
  539.     return buf; 
  540. } 
  541.  
  542. imeth long String_im_gAdvance(object self, long n)
  543. { String_iv_t *iv = GetIVs(String, self);
  544.     int len; 
  545.  
  546.     UPDATE_LEN; 
  547.     len = n > (long) iv->iLen ? iv->iLen : (int) n; 
  548.     memmove(iv->iStr, iv->iStr+len, iv->iLen-len+1); 
  549.     iv->iLen -= len; 
  550.     FREE_UNUSED; 
  551.     return (long) len; 
  552. } 
  553.  
  554. imeth long String_im_gPosition(object self)
  555. { 
  556.     USE(self); 
  557.     return 0L; 
  558. } 
  559.  
  560. imeth long String_im_gLength(object self)
  561. { String_iv_t *iv = GetIVs(String, self);
  562.     UPDATE_LEN; 
  563.     return (long) iv->iLen; 
  564. } 
  565.  
  566. imeth int String_im_gEndOfStream(object self)
  567. { String_iv_t *iv = GetIVs(String, self);
  568.     UPDATE_LEN; 
  569.     return !iv->iLen; 
  570. } 
  571.  
  572. cvmeth objrtn String_cvm_vSprintf(object self, va_list _rest_)
  573. { 
  574.     char * fmt = va_arg(_rest_, char *);
  575.  
  576. #line 569 "string.d"
  577.     char buf[256]; 
  578.     MAKE_REST(fmt); 
  579.  
  580.     vsprintf(buf, fmt, _rest_); 
  581.     return gNewWithStr(self, buf); 
  582. } 
  583.  
  584. #line 585 "string.c"
  585.  
  586. static    objrtn    String_cfm_vSprintf(object self, ...)
  587. {
  588.     va_list    _rest_;
  589.     va_start(_rest_, self);
  590.     return String_cvm_vSprintf(self, _rest_);
  591. }
  592.  
  593.  
  594.  
  595. #line 576 "string.d"
  596. ivmeth objrtn String_ivm_vBuild(object self, va_list _rest_)
  597. { String_iv_t *iv = GetIVs(String, self);char * f = va_arg(_rest_, char *);
  598.     object obj; 
  599.     char *str, *pbuf; 
  600.     va_list ap; 
  601.     int len, argn, tlen; 
  602.     static char fun[] = "Build"; 
  603.     MAKE_REST(f); 
  604. #line 588 "string.d"
  605.     UPDATE_LEN; 
  606.     if (f) 
  607.         tlen = get_string((object) f, &str, fun, 2); 
  608.     else 
  609.         tlen = iv->iLen; 
  610.     ASSIGN_VA_LIST(ap, _rest_); 
  611.     for (argn=3 ; obj = va_arg(ap, object) ; ) 
  612.         tlen += get_string(obj, &str, fun, argn++); 
  613. #line 600 "string.d"
  614.     if (tlen >= iv->iSize) { 
  615.         if (iv->iBlksz == 1 && !f) 
  616.             iv->iBlksz = ABS; 
  617.         SETSIZE(tlen + 1); 
  618.         iv->iStr = (char *) MA_realloc(iv->iStr, iv->iSize); 
  619.     } 
  620. #line 610 "string.d"
  621.     pbuf = iv->iStr; 
  622.     if (f) { 
  623.         len = get_string((object)f, &str, fun, 2); 
  624.         if (len) 
  625.             memcpy(pbuf, str, len); 
  626.         pbuf += len; 
  627.     } else 
  628.         pbuf += iv->iLen; 
  629.     for (argn=3 ; obj = GetArg(object) ; ) { 
  630.         len = get_string(obj, &str, fun, argn++); 
  631.         if (len) { 
  632.             memcpy(pbuf, str, len); 
  633.             pbuf += len; 
  634.         } 
  635.     } 
  636.     *pbuf = '\0'; 
  637.     iv->iLen = tlen; 
  638.     return self; 
  639. } 
  640.  
  641. #line 642 "string.c"
  642.  
  643. static    objrtn    String_ifm_vBuild(object self, ...)
  644. {
  645.     va_list    _rest_;
  646.     va_start(_rest_, self);
  647.     return String_ivm_vBuild(self, _rest_);
  648. }
  649.  
  650.  
  651.  
  652. #line 630 "string.d"
  653. cvmeth objrtn String_cvm_vBuild(object self, va_list _rest_)
  654. { 
  655.     object obj; 
  656.     char *str, *pbuf; 
  657.     va_list ap; 
  658.     int len, argn, tlen=0; 
  659.     static char fun[] = "Build"; 
  660.     object newObj = oSuper(String_c, gNew, self)(self); 
  661.     ivType *iv = ivPtr(newObj); 
  662.     MAKE_REST(self); 
  663.  
  664.  
  665.  
  666.  
  667.     ASSIGN_VA_LIST(ap, _rest_); 
  668.     for (argn=2 ; obj = va_arg(ap, object) ; ) 
  669.         tlen += get_string(obj, &str, fun, argn++); 
  670.  
  671.  
  672.  
  673.     iv->iBlksz = 1; 
  674.     SETSIZE(tlen + 1); 
  675.     iv->iStr = (char *) MA_malloc(iv->iSize, &iv->iStr); 
  676.  
  677.  
  678.  
  679.  
  680.     pbuf = iv->iStr; 
  681.     for (argn=2 ; obj = GetArg(object) ; ) { 
  682.         len = get_string(obj, &str, fun, argn++); 
  683.         if (len) { 
  684.             memcpy(pbuf, str, len); 
  685.             pbuf += len; 
  686.         } 
  687.     } 
  688.     *pbuf = '\0'; 
  689.     iv->iLen = tlen; 
  690.     return newObj; 
  691. } 
  692.  
  693. #line 694 "string.c"
  694.  
  695. static    objrtn    String_cfm_vBuild(object self, ...)
  696. {
  697.     va_list    _rest_;
  698.     va_start(_rest_, self);
  699.     return String_cvm_vBuild(self, _rest_);
  700. }
  701.  
  702.  
  703. #line 670 "string.d"
  704. static int get_string(object obj, char **str, char *fun, int argn) 
  705. { 
  706.     ivType *iv2; 
  707.     char buf[80]; 
  708.  
  709.     if (!obj) { 
  710.         *str = ""; 
  711.         return 0; 
  712.     } else if (!IsObj(obj)) { 
  713.         *str = (char *) obj; 
  714.         return strlen((char *) obj); 
  715.     } 
  716.     if (!gIsKindOf(obj, CLASS)) { 
  717.         sprintf(buf, "%s::String:  Arg %d incorrect type.\n", fun, argn); 
  718.         gError(Dynace, buf); 
  719.     } 
  720.     iv2 = ivPtr(obj); 
  721.     *str = iv2->iStr; 
  722.     return iv2->iCalcLen ? (iv2->iLen=strlen(iv2->iStr)) : iv2->iLen; 
  723. } 
  724.  
  725. imeth char String_im_gCharValueAt(object self, int i)
  726. { String_iv_t *iv = GetIVs(String, self);
  727.     UPDATE_LEN; 
  728.     if (i < 0 || i > iv->iLen) 
  729.         gError(self, "CharValue::String:  Index out of range.\n"); 
  730.     return iv->iStr[i]; 
  731. } 
  732.  
  733. imeth objrtn String_im_gChangeCharAt(object self, int i, int c)
  734. { String_iv_t *iv = GetIVs(String, self);
  735.     UPDATE_LEN; 
  736.     if (i < 0 || i > iv->iLen) 
  737.         gError(self, "ChangeCharAt::String:  Index out of range.\n"); 
  738.     if (i == iv->iLen) { 
  739.         char buf[2]; 
  740.         buf[0] = c; 
  741.         buf[1] = '\0'; 
  742.         return gAppend(self, (object) buf); 
  743.     } 
  744.     iv->iStr[i] = c; 
  745.     return self; 
  746. } 
  747.  
  748. imeth objrtn String_im_gToLower(object self)
  749. { String_iv_t *iv = GetIVs(String, self);
  750.     char *s; 
  751.     int len; 
  752.  
  753.     UPDATE_LEN; 
  754.     s = iv->iStr; 
  755.     len = iv->iLen; 
  756.     for ( ; len-- ; s++) 
  757.         *s = tolower(*s); 
  758.     return self; 
  759. } 
  760.  
  761. imeth objrtn String_im_gToUpper(object self)
  762. { String_iv_t *iv = GetIVs(String, self);
  763.     char *s; 
  764.     int len; 
  765.  
  766.     UPDATE_LEN; 
  767.     s = iv->iStr; 
  768.     len = iv->iLen; 
  769.     for ( ; len-- ; s++) 
  770.         *s = toupper(*s); 
  771.     return self; 
  772. } 
  773.  
  774. imeth objrtn String_im_gSubString(object self, int beg, int num)
  775. { String_iv_t *iv = GetIVs(String, self);
  776.     object obj = oSuper(String_c, gNew, CLASS)(CLASS); 
  777.     ivType *iv2 = ivPtr(obj); 
  778.  
  779.     UPDATE_LEN; 
  780.     if (beg < 0) 
  781.         beg = iv->iLen + beg; 
  782.     if (num < 0) { 
  783.         beg += num + 1; 
  784.         num = -num; 
  785.     } 
  786.  
  787.     if (beg >= iv->iLen || beg < 0) 
  788.         num = 0; 
  789.     else { 
  790.         int n = iv->iLen - beg; 
  791.         num = num < n ? num : n; 
  792.     } 
  793.     iv2->iBlksz = 1; 
  794.     SETSIZE(num+1); 
  795.     iv2->iLen = num; 
  796.     iv2->iStr = (char *) MA_malloc(iv2->iSize, &iv2->iStr); 
  797.     if (num) 
  798.         memcpy(iv2->iStr, iv->iStr+beg, num); 
  799.     iv2->iStr[num] = '\0'; 
  800.     return obj; 
  801. } 
  802.  
  803. imeth objrtn String_im_gTake(object self, int n)
  804. { String_iv_t *iv = GetIVs(String, self);
  805.     int i, len; 
  806.     char *s; 
  807.  
  808.     UPDATE_LEN; 
  809.     len = n < 0 ? -n : n; 
  810.     if (len == iv->iLen) 
  811.         return self; 
  812.     if (len >= iv->iSize) { 
  813.         SETSIZE(len + 1); 
  814.         iv->iStr = (char *) MA_realloc(iv->iStr, iv->iSize); 
  815.     } 
  816.     s = iv->iStr; 
  817.     if (n >= 0) { 
  818.         for (i=iv->iLen ; i < len ; i++) 
  819.             s[i] = ' '; 
  820.         goto end; 
  821.     } 
  822.     if (iv->iLen < len) { 
  823.         n = len - iv->iLen; 
  824.         memmove(s + n, s, iv->iLen); 
  825.         for (i = 0; i < n ; i++) 
  826.             s[i] = ' '; 
  827.         goto end; 
  828.     } 
  829.     memmove(s, s + (iv->iLen - len), len); 
  830.     end: 
  831.     s[len] = '\0'; 
  832.     iv->iLen = len; 
  833.     FREE_UNUSED; 
  834.     return self; 
  835. } 
  836.  
  837. imeth objrtn String_im_gDrop(object self, int n)
  838. { String_iv_t *iv = GetIVs(String, self);
  839.     int an; 
  840.  
  841.     if (!n) 
  842.         return self; 
  843.     UPDATE_LEN; 
  844.     an = n < 0 ? -n : n; 
  845.     if (an >= iv->iLen) 
  846.         iv->iLen = 0; 
  847.     else { 
  848.         if (n > 0) 
  849.             memmove(iv->iStr, iv->iStr + n, iv->iLen - n); 
  850.         iv->iLen -= an; 
  851.     } 
  852.     iv->iStr[iv->iLen] = '\0'; 
  853.     FREE_UNUSED; 
  854.     return self; 
  855. } 
  856.  
  857. #define ISspace(c) ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) == '\r') 
  858.  
  859. imeth objrtn String_im_gStripLeft(object self)
  860. { String_iv_t *iv = GetIVs(String, self);
  861.     int i, n; 
  862.     char *s = iv->iStr; 
  863.  
  864.     UPDATE_LEN; 
  865.     for (i=0, n=iv->iLen ; n && ISspace(s[i]) ; ++i, --n); 
  866.     if (!i) 
  867.         return self; 
  868.     if (n) 
  869.         memmove(s, s + i, n); 
  870.     iv->iLen = n; 
  871.     s[n] = '\0'; 
  872.     FREE_UNUSED; 
  873.     return self; 
  874. } 
  875.  
  876. imeth objrtn String_im_gStripRight(object self)
  877. { String_iv_t *iv = GetIVs(String, self);
  878.     int n; 
  879.     char *s = iv->iStr; 
  880.  
  881.     UPDATE_LEN; 
  882.     for (n = iv->iLen - 1 ; n >= 0 && ISspace(s[n]) ; n--); 
  883.     s[iv->iLen = n + 1] = '\0'; 
  884.     FREE_UNUSED; 
  885.     return self; 
  886. } 
  887.  
  888. imeth objrtn String_im_gStripCenter(object self)
  889. { String_iv_t *iv = GetIVs(String, self);
  890.     int i, n; 
  891.     char *s = iv->iStr; 
  892.  
  893.     UPDATE_LEN; 
  894.     for (i=0, n=iv->iLen ; n && ISspace(s[i]) ; ++i, --n); 
  895.     if (n && i) 
  896.         memmove(s, s + i, n); 
  897.     for (--n ; n >= 0 && ISspace(s[n]) ; n--); 
  898.     s[iv->iLen = n + 1] = '\0'; 
  899.     FREE_UNUSED; 
  900.     return self; 
  901. } 
  902.  
  903. imeth objrtn String_im_gJustifyLeft(object self)
  904. { String_iv_t *iv = GetIVs(String, self);
  905.     char *s = iv->iStr; 
  906.     int n, i; 
  907.  
  908.     UPDATE_LEN; 
  909.     n = iv->iLen; 
  910.     for (i=0 ; i < n && ISspace(s[i]) ; ++i); 
  911.     if (!i) 
  912.         return self; 
  913.     memmove(s, s + i, n-i); 
  914.     for (i=n-i ; i < n ; ) 
  915.         s[i++] = ' '; 
  916.     return self; 
  917. } 
  918.  
  919. imeth objrtn String_im_gJustifyRight(object self)
  920. { String_iv_t *iv = GetIVs(String, self);
  921.     char *s = iv->iStr; 
  922.     int n, i, p; 
  923.  
  924.     UPDATE_LEN; 
  925.     n = iv->iLen; 
  926.     for (i=n-1 ; i >= 0 && ISspace(s[i]) ; --i); 
  927.     p = n - (i + 1); 
  928.     if (!p) 
  929.         return self; 
  930.     memmove(s + p, s, n-p); 
  931.     for (i=0 ; i < p ; ) 
  932.         s[i++] = ' '; 
  933.     return self; 
  934. } 
  935.  
  936. imeth objrtn String_im_gJustifyCenter(object self)
  937. { String_iv_t *iv = GetIVs(String, self);
  938.     char *s = iv->iStr; 
  939.     int n, left, right, left2, p, i; 
  940.  
  941.     UPDATE_LEN; 
  942.     n = iv->iLen; 
  943.     for (left=0 ; left < n && ISspace(s[left]) ; ++left); 
  944.     for (right=0, i=n-1 ; i >= 0 && ISspace(s[i]) ; --i, ++right); 
  945.     left2 = (left + right) / 2; 
  946.     if (left2 == left) 
  947.         return self; 
  948.     if (left2 < left) { 
  949.         p = left - left2; 
  950.         memmove(s, s + p, n - p); 
  951.         for (i=n-(p+1) ; i < n ; ) 
  952.             s[i--] = ' '; 
  953.     } else { 
  954.         p = left2 - left; 
  955.         memmove(s + p, s, n - p); 
  956.         for (i=0 ; i < p ; ) 
  957.             s[i++] = ' '; 
  958.     } 
  959.     return self; 
  960. } 
  961.  
  962. imeth int String_im_gEqual(object self, object obj)
  963. { String_iv_t *iv = GetIVs(String, self);
  964.     char *str; 
  965.     int len; 
  966.  
  967.     if (EQ(self, obj)) 
  968.         return 1; 
  969.     if (IsObj(obj)) { 
  970.         ivType *iv2; 
  971.         if (NEQ(ClassOf(self), ClassOf(obj))) 
  972.             return 0; 
  973.         iv2 = ivPtr(obj); 
  974.         if (iv2->iCalcLen) 
  975.             iv2->iLen = strlen(iv2->iStr); 
  976.         len = iv2->iLen; 
  977.         str = iv2->iStr; 
  978.     } else { 
  979.         str = (char *) obj; 
  980.         len = str ? strlen(str) : 0; 
  981.     } 
  982.     UPDATE_LEN; 
  983.     if (iv->iLen != len) 
  984.         return 0; 
  985.     if (len) 
  986.         return memcmp(iv->iStr, str, len) ? 0 : 1; 
  987.     else 
  988.         return 1; 
  989. } 
  990.  
  991. imeth objrtn String_im_gCopy(object self)
  992. { 
  993.     return gNewWithObj(ClassOf(self), self); 
  994. } 
  995.  
  996.  
  997. #line 998 "string.c"
  998.  
  999. objrtn    String_initialize(void)
  1000. {
  1001.     static  CRITICALSECTION  cs;
  1002.     static  int volatile once = 0;
  1003.  
  1004.     ENTERCRITICALSECTION(_CI_CS_);
  1005.     if (!once) {
  1006.         INITIALIZECRITICALSECTION(cs);
  1007.         once = 1;
  1008.     }
  1009.     LEAVECRITICALSECTION(_CI_CS_);
  1010.  
  1011.     ENTERCRITICALSECTION(cs);
  1012.  
  1013.     if (String_c) {
  1014.         LEAVECRITICALSECTION(cs);
  1015.         return String_c;
  1016.     }
  1017.     INHIBIT_THREADER;
  1018.     Stream_initialize();
  1019.     if (String_c)  {
  1020.         ENABLE_THREADER;
  1021.         LEAVECRITICALSECTION(cs);
  1022.         return String_c;
  1023.     }
  1024.     String_c = gNewClass(Class, "String", sizeof(String_iv_t), 0, Stream, END);
  1025.     cMethodFor(String, gNewWithStr, New);
  1026.     cMethodFor(String, gNewWithInt, String_cm_gNewWithInt);
  1027.     cMethodFor(String, gNew, String_cm_gNew);
  1028.     cMethodFor(String, gNewWithObj, String_cm_gNewWithObj);
  1029.     cvMethodFor(String, vBuild, String_cvm_vBuild, String_cfm_vBuild);
  1030.     cvMethodFor(String, vSprintf, String_cvm_vSprintf, String_cfm_vSprintf);
  1031.     iMethodFor(String, gCompareNI, String_im_gCompareNI);
  1032.     iMethodFor(String, gAppend, String_im_gAppend);
  1033.     iMethodFor(String, gChangeStrValue, String_im_gChangeStrValue);
  1034.     iMethodFor(String, gPosition, String_im_gPosition);
  1035.     iMethodFor(String, gTake, String_im_gTake);
  1036.     iMethodFor(String, gLength, String_im_gLength);
  1037.     iMethodFor(String, gWrite, String_im_gWrite);
  1038.     iMethodFor(String, gCompare, String_im_gCompare);
  1039.     iMethodFor(String, gEndOfStream, String_im_gEndOfStream);
  1040.     iMethodFor(String, gCompareN, String_im_gCompareN);
  1041.     iMethodFor(String, gPrintLength, String_im_gPrintLength);
  1042.     iMethodFor(String, gCompareI, String_im_gCompareI);
  1043.     iMethodFor(String, gToLower, String_im_gToLower);
  1044.     iMethodFor(String, gAdvance, String_im_gAdvance);
  1045.     iMethodFor(String, gSize, String_im_gSize);
  1046.     ivMethodFor(String, vBuild, String_ivm_vBuild, String_ifm_vBuild);
  1047.     iMethodFor(String, gChangeCharAt, String_im_gChangeCharAt);
  1048.     iMethodFor(String, gCharValueAt, String_im_gCharValueAt);
  1049.     iMethodFor(String, gDispose, String_im_gDispose);
  1050.     iMethodFor(String, gProcess, String_im_gProcess);
  1051.     iMethodFor(String, gStripCenter, String_im_gStripCenter);
  1052.     iMethodFor(String, gEqual, String_im_gEqual);
  1053.     iMethodFor(String, gToUpper, String_im_gToUpper);
  1054.     iMethodFor(String, gJustifyRight, String_im_gJustifyRight);
  1055.     iMethodFor(String, gGets, String_im_gGets);
  1056.     iMethodFor(String, gDrop, String_im_gDrop);
  1057.     iMethodFor(String, gGCDispose, String_im_gDispose);
  1058.     iMethodFor(String, gJustifyLeft, String_im_gJustifyLeft);
  1059.     iMethodFor(String, gStringRepValue, String_im_gStringRepValue);
  1060.     iMethodFor(String, gJustifyCenter, String_im_gJustifyCenter);
  1061.     iMethodFor(String, gHash, String_im_gHash);
  1062.     iMethodFor(String, gChangeValue, ChangeValue);
  1063.     iMethodFor(String, gCopy, String_im_gCopy);
  1064.     iMethodFor(String, gSubString, String_im_gSubString);
  1065.     iMethodFor(String, gDeepDispose, String_im_gDispose);
  1066.     iMethodFor(String, gRead, String_im_gRead);
  1067.     iMethodFor(String, gDeepCopy, String_im_gCopy);
  1068.     iMethodFor(String, gStringValue, String_im_gStringValue);
  1069.     iMethodFor(String, gStripLeft, String_im_gStripLeft);
  1070.     iMethodFor(String, gStripRight, String_im_gStripRight);
  1071.  
  1072.     ENABLE_THREADER;
  1073.  
  1074.     LEAVECRITICALSECTION(cs);
  1075.  
  1076.     return String_c;
  1077. }
  1078.  
  1079.  
  1080.  
  1081.